﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using NUnit.Framework;
using Studio7i.Dominio;
using Studio7i.Persistencia;

namespace Studio7i.Pruebas
{
    public class TestReservaServicioDAO
    {

        [TestFixture]
        public class Test1_ReservaServicioDAO
        {
            // Atributos a utilizar durante las pruebas
            private ReservaServicioDAO reservaServicioDAO = null;
            private int codigoGenerado = 0;

            [TestFixtureSetUp]
            public void PrepararPruebas()
            {
                // 1. Definimos la implementación del DAO a probar (ADO / NH / EF)
                reservaServicioDAO = new Persistencia.ReservaServicioDAO();

                //2. Eliminamos todos los cientes en BD antes de las pruebas
                //foreach (ReservaServicio reservaServicio in reservaServicioDAO.ListarTodos())
                //    reservaServicioDAO.Eliminar(reservaServicio);

                // 3. Creamos 3 clientes para tenerlos disponibles en las pruebas
                //reservaServicioDAO.Crear(new ReservaServicio(1, 1, 1));
                //reservaServicioDAO.Crear(new ReservaServicio() { Codigo = 2, CodReserva = 2, CodServicio = 1 });


            }
            [Test]
            public void Test1_Crear()
            {
                // 1. Clase a probar: ReservaServicioDAO
                Assert.IsNotNull(reservaServicioDAO);

                // 2. Declaramos e instanciamos la entidad de dominio
                ReservaServicio reservaServicioACrear = new ReservaServicio();
                //reservaServicioACrear.Codigo = 1;
                reservaServicioACrear.CodReserva = 2;
                reservaServicioACrear.CodServicio = 1;

                // 3. Declaramos la entidad que contendrá el resultado
                ReservaServicio reservaServicioCreado = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    reservaServicioCreado = reservaServicioDAO.Crear(reservaServicioACrear);
                    codigoGenerado = reservaServicioCreado.Codigo;
                }, "Reserva-Servicio creada");

                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(reservaServicioCreado);
                // Probamos que el código generado sea mayor a 0
                Assert.Greater(reservaServicioCreado.Codigo, 0);

                // Probamos que el nombre registrado es igual al solicitado con la entidad
                Assert.AreEqual(reservaServicioCreado.CodReserva, reservaServicioACrear.CodReserva);
                Assert.AreEqual(reservaServicioCreado.CodServicio, reservaServicioACrear.CodServicio);

            }

            [Test]
            public void Test2_Obtener()
            {
                // 1. Clase a probar: ReservaServicioDAO
                Assert.IsNotNull(reservaServicioDAO);
                // 2. Definimos los datos para la prueba
                int codigo = 1;
                // 3. Declaramos la entidad que contendrá el resultado
                ReservaServicio reservaServicioObtenido = null;
                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    reservaServicioObtenido = reservaServicioDAO.Obtener(codigo);
                });

                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(reservaServicioObtenido);
                Assert.AreEqual(reservaServicioObtenido.Codigo, codigo);


            }

            [Test]
            public void Test3_Modificar()
            {
                // 1. Clase a probar: ReservaServicioDAO
                Assert.IsNotNull(reservaServicioDAO);

                // 2. Declaramos e instanciamos la entidad de dominio a modificar
                ReservaServicio reservaServicioAModificar = new ReservaServicio();
                reservaServicioAModificar.Codigo = 2;
                reservaServicioAModificar.CodReserva = 2;
                reservaServicioAModificar.CodServicio = 2;


                // 3. Declaramos la entidad que contendrá el resultado
                ReservaServicio reservaServicioModificado = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    reservaServicioModificado = reservaServicioDAO.Modificar(reservaServicioAModificar);
                }, "reservaServicio modificado");
                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(reservaServicioModificado);
                // Probamos que el código generado sea mayor a 0
                Assert.AreEqual(reservaServicioModificado.Codigo, 1);
                // Probamos que el nombre registrado es igual al solicitado con la entidad
                Assert.AreEqual(reservaServicioModificado.CodReserva, reservaServicioAModificar.CodReserva);
                Assert.AreEqual(reservaServicioModificado.CodServicio, reservaServicioAModificar.CodServicio);

            }

            [Test]
            public void Test4_Eliminar()
            {
                // 1. Clase a probar: ReservaServicioDAO
                Assert.IsNotNull(reservaServicioDAO);

                // 2. Declaramos e instanciamos la entidad de dominio a eliminar
                codigoGenerado = 1;
                ReservaServicio reservaServicioAEliminar = reservaServicioDAO.Obtener(codigoGenerado);

                // 3. Declaramos la entidad que contendrá el resultado
                ReservaServicio reservaServicioEliminado = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    reservaServicioDAO.Eliminar(reservaServicioAEliminar);
                }, "reservaServicio eliminado");

                // Probamos que la entidad resultante no sea nula
                Assert.IsNull(reservaServicioEliminado);

            }
            [Test]
            public void Test5_ListarTodos()
            {
                // 1. Clase a probar: ReservaServicioDAO
                Assert.IsNotNull(reservaServicioDAO);
                // 2. Declaramos la entidad que contendrá el resultado
                ICollection<ReservaServicio> reservaServiciosEncontrados = null;
                // 3. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    reservaServiciosEncontrados = reservaServicioDAO.ListarTodos();
                }, "ReservaInstrumentos Listados");

                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(reservaServiciosEncontrados);

                // Probamos que la cantidad de instrumentos encontrados sea 1
                // Assert.AreEqual(reservaServiciosEncontrados.Count, 1);

                // Probamos que cada instrumento contenga la cadena de búsqueda en su nombre
                foreach (ReservaServicio reservaServicioEncontrado in reservaServiciosEncontrados)
                {
                    Assert.IsNotNull(reservaServicioEncontrado);
                    Assert.IsInstanceOf(typeof(ReservaServicio), reservaServicioEncontrado);
                }
            }

        }   
    }
}